﻿////#include <iostream>
////using namespace std;
//////
//////typedef int DataType;
//////struct Stack
//////{
//////    void Init(size_t capacity)
//////    {
//////        _array = (DataType*)malloc(sizeof(DataType) * capacity);
//////        if (nullptr == _array)
//////        {
//////            perror("malloc申请空间失败");
//////            return;
//////        }
//////        _capacity = capacity;
//////        _size = 0;
//////    }
//////    void Push(const DataType& data)
//////    {
//////        // 扩容
//////        _array[_size] = data;
//////        ++_size;
//////    }
//////    DataType Top()
//////    {
//////        return _array[_size - 1];
//////    }
//////    void Destroy()
//////    {
//////        if (_array)
//////        {
//////            free(_array);
//////            _array = nullptr;
//////            _capacity = 0;
//////            _size = 0;
//////        }
//////    }
//////    DataType* _array;
//////    size_t _capacity;
//////    size_t _size;
//////};
//////class A
//////{
//////public:
//////    A(int a)
//////        :_a(a)
//////    {}
//////private:
//////    int _a;
//////};
//////class B
//////{
//////public:
//////    B(int a, int ref)
//////        :_aobj(a)
//////        , _ref(ref)
//////        , _n(10)
//////    {}
//////private:
//////    A _aobj; // 没有默认构造函数
//////    int& _ref; // 引用
//////    const int _n; // const
//////};
//////
//////int main()
//////{
//////   /* Stack s;
//////    s.Init(10);
//////    s.Push(1);
//////    s.Push(2);
//////    s.Push(3);
//////    cout << s.Top() << endl;
//////    s.Destroy();*/
//////    B a(1,2);
//////
//////    return 0;
//////}
////
//////class Person
//////{
//////public:
//////	void PrintPersonInfo();
//////private:
//////	char _name[20];
//////	char _gender[3];
//////	int _age;
//////};
//////// 这里需要指定PrintPersonInfo是属于Person这个类域
//////void Person::PrintPersonInfo()
//////{
//////	cout << _name << " " << _gender << " " << _age << endl;
//////}
//////// 类中既有成员变量，又有成员函数
//////class A1 {
//////public:
//////    void f1() {}
//////private:
//////    int _a;
//////};
//////
//////// 类中仅有成员函数
//////class A2 {
//////public:
//////    void f2() {}
//////};
//////
//////// 类中什么都没有---空类
//////class A3
//////{};
//////class Date
//////{
//////public:
//////    void Init(int year, int month, int day)
//////    {
//////        _year = year;
//////        _month = month;
//////        _day = day;
//////    }
//////    void Print()
//////    {
//////        cout << _year << "-" << _month << "-" << _day << endl;
//////    }
//////private:
//////    int _year; // 年
//////    int _month; // 月
//////    int _day; // 日
//////};
//////
//////int main()
//////{
//////    Date d1, d2;
//////    d1.Init(2022, 1, 11);
//////    d2.Init(2022, 1, 12);
//////    d1.Print();
//////    d2.Print();
//////    return 0;
//////}
//////
//////class B {
//////public:
//////	B()
//////	{
//////		_b = 0;
//////	}
//////	B(int a = 1)
//////	{
//////		_b = a;
//////	}
//////private:
//////	int _b;
//////};
//////
//////class Date {
//////public:
//////	Date(int year = 1,int month = 1, int day = 1)
//////	{
//////		_year = year;
//////		_month = month;
//////		_day = day;
//////	}
//////
//////	Date(const Date& a)
//////	{
//////		_year = a._year;
//////		_month = a._month;
//////		_day = a._day;
//////	}
//////	/*Date(const Date* a)
//////	{
//////		_year = a->_year;
//////		_month = a->_month;
//////		_day = a->_day;
//////	}*/
//////
//////	void Print()
//////	{
//////		cout << _year << endl;
//////		cout << _month << endl;
//////		cout << _day << endl;
//////		//cout << this << endl;
//////		//cout << this->_a << endl;
//////	}
//////private:
//////	int _year;
//////	int _month;
//////	int _day;
//////};
//////
//////
//////int main()
//////{
//////	Date a(2024,4,9);
//////	Date a1(a);//调用引用的拷贝构造函数//注意我们一旦自己写了引用的拷贝构造函数编译器就不会自动生成。
//////	//Date a1(&a)//调用取地址的拷贝构造函数//如果不写引用的拷贝构造函数，编译器会自动生成Date a1(a)则会调用编译器自动生成的，
//////	//如果取地址的拷贝构造函数不写，由于引用的特性也会调用编译器自己生成的拷贝构造函数
//////	a.Print();
//////	a1.Print();
//////	return 0;
//////}
////
//////// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
//////class A
//////{
//////public:
//////    void Print()
//////    {
//////        cout << "Print()" << endl;
//////        cout << this << endl;
//////        cout << _a << endl;
//////        //cout << this->_a << endl;
//////    }
//////private:
//////    int _a;
//////};
//////int main()
//////{
//////    A* p = nullptr;
//////    p->Print();
//////    return 0;
//////}
////
//////typedef int DataType;
//////typedef struct Stack
//////{
//////	DataType* array;
//////	int capacity;
//////	int size;
//////}Stack;
//////void StackInit(Stack* ps)
//////{
//////	assert(ps);
//////	ps->array = (DataType*)malloc(sizeof(DataType) * 3);
//////	if (NULL == ps->array)
//////	{
//////		assert(0);
//////		return;
//////	}
//////	ps->capacity = 3;
//////	ps->size = 0;
//////}
//////void StackDestroy(Stack* ps)
//////{
//////	assert(ps);
//////	if (ps->array)
//////	{
//////		free(ps->array);
//////		ps->array = NULL;
//////		ps->capacity = 0;
//////		ps->size = 0;
//////	}
//////}
//////void CheckCapacity(Stack* ps)
//////{
//////	if (ps->size == ps->capacity)
//////	{
//////		int newcapacity = ps->capacity * 2;
//////		DataType* temp = (DataType*)realloc(ps->array,
//////			newcapacity * sizeof(DataType));
//////		if (temp == NULL)
//////		{
//////			perror("realloc申请空间失败!!!");
//////			return;
//////		}
//////		ps->array = temp;
//////		ps->capacity = newcapacity;
//////	}
//////}
//////void StackPush(Stack* ps, DataType data)
//////{
//////	assert(ps);
//////	CheckCapacity(ps);
//////	ps->array[ps->size] = data;
//////	ps->size++;
//////}
//////int StackEmpty(Stack* ps)
//////{
//////	assert(ps);
//////	return 0 == ps->size;
//////}
//////void StackPop(Stack* ps)
//////{
//////	if (StackEmpty(ps))
//////		return;
//////	ps->size--;
//////}
//////DataType StackTop(Stack* ps)
//////{
//////	assert(!StackEmpty(ps));
//////	return ps->array[ps->size - 1];
//////}
//////int StackSize(Stack* ps)
//////{
//////	assert(ps);
//////	return ps->size;
//////}
//////int main()
//////{
//////	Stack s;
//////	StackInit(&s);
//////	StackPush(&s, 1);
//////	StackPush(&s, 2);
//////	StackPush(&s, 3);
//////	StackPush(&s, 4);
//////	printf("%d\n", StackTop(&s));
//////	printf("%d\n", StackSize(&s));
//////	StackPop(&s);
//////	StackPop(&s);
//////	printf("%d\n", StackTop(&s));
//////	printf("%d\n", StackSize(&s));
//////	StackDestroy(&s);
//////	return 0;
//////}
////
//////C++实现栈
//////typedef int STDataType;
//////class Stack {
//////public:
//////	void Print()
//////	{
//////		if (_size == 0)
//////			return;
//////		for (int i = 0; i < _size;i++)
//////		{
//////			cout << _array[i] << endl;
//////		}
//////	}
//////
//////	//栈的初始化
//////	void Init(int capacity = 4)
//////	{
//////		_array = (STDataType*)malloc(sizeof(STDataType) * capacity);
//////		if (_array == NULL)
//////		{
//////			perror("malloc fail!");
//////			exit(1);
//////		}
//////		_capacity = 4;
//////		_size = 0;
//////	}
//////	
//////	void Push(STDataType x)
//////	{
//////		//内存检查
//////		CheckCapacity();
//////		//插入
//////		_array[_size++] = x;
//////	}
//////
//////	void Pop()
//////	{
//////		if (!Empty())
//////			_size--;
//////			return;
//////	}
//////	bool Empty()
//////	{
//////		return _size == 0;
//////	}
//////	int Size()
//////	{
//////		return _size;
//////	}
//////	STDataType Top()
//////	{
//////		if (!Empty())
//////			return _array[_size - 1];
//////	}
//////	void Destroy()
//////	{
//////		if (_array)
//////		{
//////			free(_array);
//////			_array = NULL;
//////			_capacity = 0;
//////			_size = 0;
//////		}
//////	}
//////	
//////private:
//////	void CheckCapacity()
//////	{
//////		if (_size == _capacity)
//////		{
//////			int newcapacity = _capacity * 2;
//////			STDataType* tmp = (STDataType*)realloc(_array, sizeof(STDataType) * newcapacity);
//////			if (tmp == NULL) {
//////				perror("realloc fail1");
//////				exit(1);
//////			}
//////			_array = tmp;
//////			_capacity = newcapacity;
//////		}
//////	}
//////private:
//////	STDataType* _array;
//////	int _size;
//////	int _capacity;
//////};
//////int main()
//////{
//////
//////	Stack s;
//////	s.Init();
//////	s.Push(1);
//////	s.Push(2);
//////	s.Push(3);
//////	s.Print();
//////	s.Pop();
//////	s.Print();
//////	s.Destroy();
//////
//////	return 0;
//////}
////
////
//////class Date
//////{
//////public:
//////    void Init(int year, int month, int day)
//////    {
//////        _year = year;
//////        _month = month;
//////        _day = day;
//////    }
//////    void Print()
//////    {
//////        cout << _year << "-" << _month << "-" << _day << endl;
//////    }
//////private:
//////    int _year;
//////    int _month;
//////    int _day;
//////};
//////
//////int main()
//////{
//////    Date d1;
//////    d1.Init(2022, 7, 5);
//////    d1.Print();
//////    Date d2;
//////    d2.Init(2022, 7, 6);
//////    d2.Print();
//////    return 0;
//////}
////
//////class Date
//////{
//////public:
//////	// 1.无参构造函数
//////	Date()
//////	{
//////
//////	}
//////	// 2.带参构造函数
//////	Date(int year, int month, int day)
//////	{
//////		_year = year; _month = month;
//////		_day = day;
//////	}
//////	// 3.全缺省构造函数
//////	Date(int year = 1, int month = 1, int day = 1)
//////	{
//////		_year = year; _month = month;
//////		_day = day;
//////	}
//////private:
//////	int _year;
//////	int _month;
//////	int _day;
//////};
//////int main()
//////{
////// 	Date d1; // 调用无参构造函数
//////	Date d2(2015, 1, 1); // 调用带参的构造函数
//////	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
//////	// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
//////	// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
//////	Date d3();
//////	return 0;
//////}
////
//////
//////class Date
//////{
//////public:
//////	
//////	// 如果用户显式定义了构造函数，编译器将不再生成
//////	Date(int year = 1, int month = 1, int day = 1)
//////	{
//////	_year = year;
//////	_month = month;
//////	_day = day;
//////	}
//////	
//////
//////	void Print()
//////	{
//////		cout << _year << "-" << _month << "-" << _day << endl;
//////	}
//////
//////private:
//////	int _year;
//////	int _month;
//////	int _day;
//////};
//////
//////int main()
//////{
//////	// 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函
//////
//////	// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再
//////
//////	// 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
//////	Date d1;
//////	return 0;
//////}
////
////class Time
////{
////public:
////	Time()
////	{
////		cout << "Time()" << endl;
////		_hour = 0;
////		_minute = 0; _second = 0;
////	}
////private:
////	int _hour;
////	int _minute;
////	int _second;
////};
////class Date
////{
////public:
////	Date(int year = 1, int month = 1,int day = 1)
////	{
////		_year = year;
////		_month = month;
////		_day = day;
////	}
////private:
////	// 基本类型(内置类型)//不实例化类这里不会开空间，这里相当于给缺省值。
////	int _year = 1970;
////	int _month = 1;
////	int _day = 1;
////	// 自定义类型
////	Time _t;
////};
////int main()
////{
////	Date d;
////	return 0;
////}
//#include <iostream>
//using namespace std;
////
////typedef int DataType;
////class Stack
////{
////public:
////	Stack(size_t capacity = 3)
////	{
////		_array = (DataType*)malloc(sizeof(DataType) * capacity);
////		if (NULL == _array)
////		{
////			perror("malloc申请空间失败!!!");
////			return;
////		}
////		_capacity = capacity;
////		_size = 0;
////	}
////	void Push(DataType data)
////	{
////		// CheckCapacity();
////		_array[_size] = data;
////		_size++;
////	}
////	// 其他方法...
////	~Stack()
////	{
////		if (_array)
////		{
////			free(_array);
////			_array = NULL;
////			_capacity = 0;
////			_size = 0;
////		}
////	}
////private:
////	DataType* _array;
////	int _capacity;
////	int _size;
////};
////void TestStack()
////{
////	Stack s;
////	s.Push(1);
////	s.Push(2);
////}
//
//class Time
//{
//public:
//	~Time()
//	{
//		cout << "~Time()" << endl;
//	}
//private:
//	int _hour;
//	int _minute;
//	int _second;
//};
//class Date
//{
//private:
//	// 基本类型(内置类型)
//	int _year = 1970;
//	int _month = 1;
//	int _day = 1;
//	// 自定义类型
//	Time _t;
//};
//int main()
//{
//	Date d;
//	return 0;
//}
//// 程序运行结束后输出：~Time()
//// 在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
//// 因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month,_day三个是
//// 内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对象，所以在
//// d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：main函数
//// 中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函
//// 数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time
//// 类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁
//// main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数
//// 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数
//#include <iostream>
//using namespace std;
//class A {
//public:
//    A()
//    {
//        cout << "A()" << endl;
//    }
//    ~A()
//    {
//        cout << "~A()" << endl;
//    }
//};
//class B {
//public:
//    B()
//    {
//        cout << "B()" << endl;
//    }
//    ~B()
//    {
//        cout << "~B()" << endl;
//    }
//};
//class C {
//public:
//    C()
//    {
//        cout << "C()" << endl;
//    }
//    ~C()
//    {
//        cout << "~C()" << endl;
//    }
//};
//
//class D {
//public:
//    D()
//    {
//        cout << "D()" << endl;
//    }
//    ~D()
//    {
//        cout << "~D()" << endl;
//    }
//};
//
//C c;
//int main()
//{
//    A a;
//    B b;
//    static D d;
//    return 0;
//}

//class Date
//{
//public:
//    Date(int year = 1900, int month = 1, int day = 1)
//    {
//        _year = year;
//        _month = month;
//        _day = day;
//    }
//    // Date(const Date& d) // 正确写法
//    Date(const Date d) // 错误写法：编译报错，会引发无穷递归
//    {
//        _year = d._year;
//        _month = d._month;
//        _day = d._day;
//    }
//private:
//    int _year;
//    int _month;
//    int _day;
//};
//int main()
//{
//    Date d1;
//    Date d2(d1);//有这样的操作就会调用拷贝构造函数。
//    return 0;
//}
#include <iostream>
using namespace std;
//class Time
//{
//public:
//    Time()
//    {
//        _hour = 1;
//        _minute = 1;
//        _second = 1;
//    }
//    Time(const Time& t)
//    {
//        _hour = t._hour;
//        _minute = t._minute;
//        _second = t._second;
//        cout << "Time::Time(const Time&)" << endl;
//    }
//private:
//    int _hour;
//    int _minute;
//    int _second;
//};
//class Date
//{
//private:
//    // 基本类型(内置类型)
//    int _year = 1970;
//    int _month = 1;
//    int _day = 1;
//    // 自定义类型
//    Time _t;
//};
//int main()
//{
//    Date d1;
//    // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
//    // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构
//    //造函数
//    Date d2(d1);
//    return 0;
//}

//class Date {
//public:
//	Date(int year,int month,int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	//Date(const Date& d)
//	//{
//	//	cout << "Date(const Date& d)" << endl;
//	//	_year = d._year;
//	//	_month = d._month;
//	//	_day = d._day;
//	//}
//	Date(const Date* d)
//	{
//		cout << "Date(const Date* d)" << endl;
//		_year = d->_year;
//		_month = d->_month;
//		_day = d->_day;
//	}
//	void Print()
//	{
//		cout << _year << '-' << _month << '-' << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1(2024,4,12);
//	Date d2(d1);//传对象，会调用Date(const Date& d)？
//	Date d3(&d1);//传地址，会调用Date(const Date* d)？
//	return 0;
//}


//// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
//typedef int DataType;
//class Stack
//{
//public:
//	Stack(size_t capacity = 10)
//	{
//		_array = (DataType*)malloc(capacity * sizeof(DataType));
//		if (nullptr == _array)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}_size = 0;
//		_capacity = capacity;
//	}
//	void Push(const DataType& data)
//	{
//		// CheckCapacity();
//		_array[_size] = data;
//		_size++;
//	}
//	~Stack()
//	{
//		if (_array)
//		{
//			free(_array);
//			_array = nullptr;
//			_capacity = 0;
//			_size = 0;
//		}
//	}
//private:
//	DataType* _array;
//	size_t _size;
//	size_t _capacity;
//};
//int main()
//{
//	Stack s1;
//	s1.Push(1);
//	s1.Push(2);
//	s1.Push(3);
//	s1.Push(4);
//	Stack s2(s1);
//	return 0;
//}

class Date
{
public:
	Date(int year, int minute, int day)
	{
		cout << "Date(int,int,int):" << this << endl;
	}
	Date(const Date& d)
	{
		cout << "Date(const Date& d):" << this << endl;
	}
	~Date()
	{
		cout << "~Date():" << this << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
Date Test(Date d)
{
	Date temp(d);
	return temp;
}
int main()
{
	Date d1(2022, 1, 13);
	Test(d1);
	return 0;
}